/**************************************************************************************
 * Copyright (c) 2005, 2006 Generative Software Development Lab, University of Waterloo
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   1. Generative Software Development Lab, University of Waterloo,
 *      http://gp.uwaterloo.ca  - initial API and implementation
 **************************************************************************************/
package ca.uwaterloo.gp.fmp.constraints.xpath;

import Data.SICParser;

/**
 * 
 * @author Vinay Kumar Singh
 *
 */

public class Parser extends SICParser {

     String[] rule1 = {"XPath","ExprSequence"};
     String[] rule2 = {"ExprSequence","Expr","terminatingCharacter"};
     String[] rule3 = {"Expr","ParenthesizeExpr","equivalence","ParenthesizeExpr"};
     String[] rule4 = {"Expr","ParenthesizeExpr","implication","ParenthesizeExpr"};
     String[] rule5 = {"Expr","not","OrExpr"};
     String[] rule6 = {"Expr","OrExpr"};
     String[] rule7 = {"OrExpr","AndExpr","or","OrExpr"};
     String[] rule8 = {"OrExpr","AndExpr"};
     String[] rule9 = {"AndExpr","ForExpr","and","AndExpr"};
     String[] rule10 = {"AndExpr","ForExpr"};
     String[] rule11 = {"ForExpr","QuantifiedExpr"};
     String[] rule12 = {"QuantifiedExpr","every","dollar","name","in","Expr","satisfies","QuantifiedExpr"};
     String[] rule13 = {"QuantifiedExpr","some","dollar","name","in","Expr","satisfies","QuantifiedExpr"};
     String[] rule14 = {"QuantifiedExpr","IfExpr"};
     String[] rule15 = {"IfExpr","if","openingParenth","Expr","closingParenth","then","Expr","else","IfExpr"};
     String[] rule16 = {"IfExpr","InstanceOfExpr"};
     String[] rule17 = {"InstanceOfExpr","CastableExpr"};
     String[] rule18 = {"CastableExpr","ComparisonExpr"};
     String[] rule19 = {"ComparisonExpr","RangeExpr","comparison","RangeExpr"};
     String[] rule20 = {"ComparisonExpr","RangeExpr"};
     String[] rule21 = {"RangeExpr","AdditiveExpr"};
     String[] rule22 = {"AdditiveExpr","MultiplicativeExpr","subtract","AdditiveExpr"};
     String[] rule23 = {"AdditiveExpr","MultiplicativeExpr","add","AdditiveExpr"};
     String[] rule24 = {"AdditiveExpr","MultiplicativeExpr"};
     String[] rule25 = {"MultiplicativeExpr","UnaryExpr","divide","MultiplicativeExpr"};
     String[] rule26 = {"MultiplicativeExpr","UnaryExpr","multiply","MultiplicativeExpr"};
     String[] rule27 = {"MultiplicativeExpr","UnaryExpr"};
     String[] rule28 = {"UnaryExpr","add","UnaryExpr"};
     String[] rule29 = {"UnaryExpr","subtract","UnaryExpr"};
     String[] rule30 = {"UnaryExpr","UnionExpr"};
     String[] rule31 = {"UnionExpr","UnionExpr","union","IntersectExceptExpr"};
     String[] rule32 = {"UnionExpr","IntersectExceptExpr"};
     String[] rule33 = {"IntersectExceptExpr","ValueExpr"};
     String[] rule34 = {"ValueExpr","PathExpr"};
     String[] rule35 = {"PathExpr","RelativePathExpr"};
     String[] rule36 = {"PathExpr","backslash","backslash","RelativePathExpr"};
     String[] rule37 = {"PathExpr","backslash","RelativePathExpr"};
     String[] rule38 = {"PathExpr","backslash"};
     String[] rule39 = {"RelativePathExpr","RelativePathExpr","backslash","backslash","StepExpr"};
     String[] rule40 = {"RelativePathExpr","RelativePathExpr","backslash","StepExpr"};
     String[] rule41 = {"RelativePathExpr","StepExpr"};
     String[] rule42 = {"StepExpr","PrimaryExpr"};
     String[] rule43 = {"PrimaryExpr","dollar","name"};
     String[] rule44 = {"PrimaryExpr","Literal"};
     String[] rule45 = {"PrimaryExpr","ParenthesizeExpr"};
     String[] rule46 = {"PrimaryExpr","FunctionCall"};
     String[] rule47 = {"Literal","StringLiteral"};
     String[] rule48 = {"Literal","NumericLiteral"};
     String[] rule49 = {"FunctionCall","booleanFunc"};
     String[] rule50 = {"ParenthesizeExpr","openingParenth","Expr","closingParenth"};
     String[] rule51 = {"NumericLiteral","digits"};
     String[] rule52 = {"StringLiteral","name"};

     public Parser() {

          rule(1,rule1);
          rule(2,rule2);
          rule(3,rule3);
          rule(4,rule4);
          rule(5,rule5);
          rule(6,rule6);
          rule(7,rule7);
          rule(8,rule8);
          rule(9,rule9);
          rule(10,rule10);
          rule(11,rule11);
          rule(12,rule12);
          rule(13,rule13);
          rule(14,rule14);
          rule(15,rule15);
          rule(16,rule16);
          rule(17,rule17);
          rule(18,rule18);
          rule(19,rule19);
          rule(20,rule20);
          rule(21,rule21);
          rule(22,rule22);
          rule(23,rule23);
          rule(24,rule24);
          rule(25,rule25);
          rule(26,rule26);
          rule(27,rule27);
          rule(28,rule28);
          rule(29,rule29);
          rule(30,rule30);
          rule(31,rule31);
          rule(32,rule32);
          rule(33,rule33);
          rule(34,rule34);
          rule(35,rule35);
          rule(36,rule36);
          rule(37,rule37);
          rule(38,rule38);
          rule(39,rule39);
          rule(40,rule40);
          rule(41,rule41);
          rule(42,rule42);
          rule(43,rule43);
          rule(44,rule44);
          rule(45,rule45);
          rule(46,rule46);
          rule(47,rule47);
          rule(48,rule48);
          rule(49,rule49);
          rule(50,rule50);
          rule(51,rule51);
          rule(52,rule52);

          actionTable(1,"Literal",SHIFT,17);
          actionTable(1,"openingParenth",SHIFT,6);
          actionTable(1,"ValueExpr",SHIFT,31);
          actionTable(1,"CastableExpr",SHIFT,55);
          actionTable(1,"UnionExpr",SHIFT,28);
          actionTable(1,"PrimaryExpr",SHIFT,16);
          actionTable(1,"IntersectExceptExpr",SHIFT,34);
          actionTable(1,"some",SHIFT,40);
          actionTable(1,"IfExpr",SHIFT,53);
          actionTable(1,"digits",SHIFT,9);
          actionTable(1,"RangeExpr",SHIFT,57);
          actionTable(1,"RelativePathExpr",SHIFT,33);
          actionTable(1,"XPath",SHIFT,91);
          actionTable(1,"StepExpr",SHIFT,23);
          actionTable(1,"add",SHIFT,25);
          actionTable(1,"NumericLiteral",SHIFT,20);
          actionTable(1,"Expr",SHIFT,93);
          actionTable(1,"QuantifiedExpr",SHIFT,52);
          actionTable(1,"every",SHIFT,36);
          actionTable(1,"dollar",SHIFT,10);
          actionTable(1,"InstanceOfExpr",SHIFT,54);
          actionTable(1,"not",SHIFT,44);
          actionTable(1,"if",SHIFT,2);
          actionTable(1,"AdditiveExpr",SHIFT,60);
          actionTable(1,"ForExpr",SHIFT,49);
          actionTable(1,"ComparisonExpr",SHIFT,56);
          actionTable(1,"FunctionCall",SHIFT,18);
          actionTable(1,"ParenthesizeExpr",SHIFT,75);
          actionTable(1,"ExprSequence",SHIFT,92);
          actionTable(1,"PathExpr",SHIFT,32);
          actionTable(1,"subtract",SHIFT,26);
          actionTable(1,"UnaryExpr",SHIFT,64);
          actionTable(1,"backslash",SHIFT,7);
          actionTable(1,"booleanFunc",SHIFT,5);
          actionTable(1,"StringLiteral",SHIFT,21);
          actionTable(1,"name",SHIFT,4);
          actionTable(1,"OrExpr",SHIFT,74);
          actionTable(1,"MultiplicativeExpr",SHIFT,61);
          actionTable(1,"AndExpr",SHIFT,46);

          actionTable(2,"openingParenth",SHIFT,3);

          actionTable(3,"Literal",SHIFT,17);
          actionTable(3,"openingParenth",SHIFT,6);
          actionTable(3,"ValueExpr",SHIFT,31);
          actionTable(3,"CastableExpr",SHIFT,55);
          actionTable(3,"UnionExpr",SHIFT,28);
          actionTable(3,"PrimaryExpr",SHIFT,16);
          actionTable(3,"IntersectExceptExpr",SHIFT,34);
          actionTable(3,"some",SHIFT,40);
          actionTable(3,"IfExpr",SHIFT,53);
          actionTable(3,"digits",SHIFT,9);
          actionTable(3,"RangeExpr",SHIFT,57);
          actionTable(3,"RelativePathExpr",SHIFT,33);
          actionTable(3,"StepExpr",SHIFT,23);
          actionTable(3,"add",SHIFT,25);
          actionTable(3,"NumericLiteral",SHIFT,20);
          actionTable(3,"Expr",SHIFT,85);
          actionTable(3,"QuantifiedExpr",SHIFT,52);
          actionTable(3,"every",SHIFT,36);
          actionTable(3,"dollar",SHIFT,10);
          actionTable(3,"InstanceOfExpr",SHIFT,54);
          actionTable(3,"not",SHIFT,44);
          actionTable(3,"if",SHIFT,2);
          actionTable(3,"AdditiveExpr",SHIFT,60);
          actionTable(3,"ForExpr",SHIFT,49);
          actionTable(3,"ComparisonExpr",SHIFT,56);
          actionTable(3,"FunctionCall",SHIFT,18);
          actionTable(3,"ParenthesizeExpr",SHIFT,75);
          actionTable(3,"PathExpr",SHIFT,32);
          actionTable(3,"subtract",SHIFT,26);
          actionTable(3,"UnaryExpr",SHIFT,64);
          actionTable(3,"backslash",SHIFT,7);
          actionTable(3,"booleanFunc",SHIFT,5);
          actionTable(3,"StringLiteral",SHIFT,21);
          actionTable(3,"name",SHIFT,4);
          actionTable(3,"OrExpr",SHIFT,74);
          actionTable(3,"MultiplicativeExpr",SHIFT,61);
          actionTable(3,"AndExpr",SHIFT,46);

          actionTable(4,"divide",REDUCE,52);
          actionTable(4,"multiply",REDUCE,52);
          actionTable(4,"subtract",REDUCE,52);
          actionTable(4,"add",REDUCE,52);
          actionTable(4,"comparison",REDUCE,52);
          actionTable(4,"and",REDUCE,52);
          actionTable(4,"or",REDUCE,52);
          actionTable(4,"terminatingCharacter",REDUCE,52);
          actionTable(4,"union",REDUCE,52);
          actionTable(4,"backslash",REDUCE,52);
          actionTable(4,"satisfies",REDUCE,52);
          actionTable(4,"closingParenth",REDUCE,52);
          actionTable(4,"else",REDUCE,52);

          actionTable(5,"divide",REDUCE,49);
          actionTable(5,"multiply",REDUCE,49);
          actionTable(5,"subtract",REDUCE,49);
          actionTable(5,"add",REDUCE,49);
          actionTable(5,"comparison",REDUCE,49);
          actionTable(5,"and",REDUCE,49);
          actionTable(5,"or",REDUCE,49);
          actionTable(5,"terminatingCharacter",REDUCE,49);
          actionTable(5,"union",REDUCE,49);
          actionTable(5,"backslash",REDUCE,49);
          actionTable(5,"satisfies",REDUCE,49);
          actionTable(5,"closingParenth",REDUCE,49);
          actionTable(5,"else",REDUCE,49);

          actionTable(6,"Literal",SHIFT,17);
          actionTable(6,"openingParenth",SHIFT,6);
          actionTable(6,"ValueExpr",SHIFT,31);
          actionTable(6,"CastableExpr",SHIFT,55);
          actionTable(6,"UnionExpr",SHIFT,28);
          actionTable(6,"PrimaryExpr",SHIFT,16);
          actionTable(6,"IntersectExceptExpr",SHIFT,34);
          actionTable(6,"some",SHIFT,40);
          actionTable(6,"IfExpr",SHIFT,53);
          actionTable(6,"digits",SHIFT,9);
          actionTable(6,"RangeExpr",SHIFT,57);
          actionTable(6,"RelativePathExpr",SHIFT,33);
          actionTable(6,"StepExpr",SHIFT,23);
          actionTable(6,"add",SHIFT,25);
          actionTable(6,"NumericLiteral",SHIFT,20);
          actionTable(6,"Expr",SHIFT,83);
          actionTable(6,"QuantifiedExpr",SHIFT,52);
          actionTable(6,"every",SHIFT,36);
          actionTable(6,"dollar",SHIFT,10);
          actionTable(6,"InstanceOfExpr",SHIFT,54);
          actionTable(6,"not",SHIFT,44);
          actionTable(6,"if",SHIFT,2);
          actionTable(6,"AdditiveExpr",SHIFT,60);
          actionTable(6,"ForExpr",SHIFT,49);
          actionTable(6,"ComparisonExpr",SHIFT,56);
          actionTable(6,"FunctionCall",SHIFT,18);
          actionTable(6,"ParenthesizeExpr",SHIFT,75);
          actionTable(6,"PathExpr",SHIFT,32);
          actionTable(6,"subtract",SHIFT,26);
          actionTable(6,"UnaryExpr",SHIFT,64);
          actionTable(6,"backslash",SHIFT,7);
          actionTable(6,"booleanFunc",SHIFT,5);
          actionTable(6,"StringLiteral",SHIFT,21);
          actionTable(6,"name",SHIFT,4);
          actionTable(6,"OrExpr",SHIFT,74);
          actionTable(6,"MultiplicativeExpr",SHIFT,61);
          actionTable(6,"AndExpr",SHIFT,46);

          actionTable(7,"FunctionCall",SHIFT,18);
          actionTable(7,"RelativePathExpr",SHIFT,24);
          actionTable(7,"openingParenth",SHIFT,6);
          actionTable(7,"PrimaryExpr",SHIFT,16);
          actionTable(7,"NumericLiteral",SHIFT,20);
          actionTable(7,"Literal",SHIFT,17);
          actionTable(7,"ParenthesizeExpr",SHIFT,19);
          actionTable(7,"name",SHIFT,4);
          actionTable(7,"digits",SHIFT,9);
          actionTable(7,"booleanFunc",SHIFT,5);
          actionTable(7,"StringLiteral",SHIFT,21);
          actionTable(7,"backslash",SHIFT,8);
          actionTable(7,"StepExpr",SHIFT,23);
          actionTable(7,"dollar",SHIFT,10);
          actionTable(7,"divide",REDUCE,38);
          actionTable(7,"multiply",REDUCE,38);
          actionTable(7,"subtract",REDUCE,38);
          actionTable(7,"add",REDUCE,38);
          actionTable(7,"comparison",REDUCE,38);
          actionTable(7,"and",REDUCE,38);
          actionTable(7,"or",REDUCE,38);
          actionTable(7,"terminatingCharacter",REDUCE,38);
          actionTable(7,"union",REDUCE,38);
          actionTable(7,"satisfies",REDUCE,38);
          actionTable(7,"closingParenth",REDUCE,38);
          actionTable(7,"else",REDUCE,38);

          actionTable(8,"FunctionCall",SHIFT,18);
          actionTable(8,"RelativePathExpr",SHIFT,12);
          actionTable(8,"openingParenth",SHIFT,6);
          actionTable(8,"PrimaryExpr",SHIFT,16);
          actionTable(8,"NumericLiteral",SHIFT,20);
          actionTable(8,"Literal",SHIFT,17);
          actionTable(8,"ParenthesizeExpr",SHIFT,19);
          actionTable(8,"name",SHIFT,4);
          actionTable(8,"digits",SHIFT,9);
          actionTable(8,"booleanFunc",SHIFT,5);
          actionTable(8,"StringLiteral",SHIFT,21);
          actionTable(8,"StepExpr",SHIFT,23);
          actionTable(8,"dollar",SHIFT,10);

          actionTable(9,"divide",REDUCE,51);
          actionTable(9,"multiply",REDUCE,51);
          actionTable(9,"subtract",REDUCE,51);
          actionTable(9,"add",REDUCE,51);
          actionTable(9,"comparison",REDUCE,51);
          actionTable(9,"and",REDUCE,51);
          actionTable(9,"or",REDUCE,51);
          actionTable(9,"terminatingCharacter",REDUCE,51);
          actionTable(9,"union",REDUCE,51);
          actionTable(9,"backslash",REDUCE,51);
          actionTable(9,"satisfies",REDUCE,51);
          actionTable(9,"closingParenth",REDUCE,51);
          actionTable(9,"else",REDUCE,51);

          actionTable(10,"name",SHIFT,11);

          actionTable(11,"divide",REDUCE,43);
          actionTable(11,"multiply",REDUCE,43);
          actionTable(11,"subtract",REDUCE,43);
          actionTable(11,"add",REDUCE,43);
          actionTable(11,"comparison",REDUCE,43);
          actionTable(11,"and",REDUCE,43);
          actionTable(11,"or",REDUCE,43);
          actionTable(11,"terminatingCharacter",REDUCE,43);
          actionTable(11,"union",REDUCE,43);
          actionTable(11,"backslash",REDUCE,43);
          actionTable(11,"satisfies",REDUCE,43);
          actionTable(11,"closingParenth",REDUCE,43);
          actionTable(11,"else",REDUCE,43);

          actionTable(12,"backslash",SHIFT,13);
          actionTable(12,"divide",REDUCE,36);
          actionTable(12,"multiply",REDUCE,36);
          actionTable(12,"subtract",REDUCE,36);
          actionTable(12,"add",REDUCE,36);
          actionTable(12,"comparison",REDUCE,36);
          actionTable(12,"and",REDUCE,36);
          actionTable(12,"or",REDUCE,36);
          actionTable(12,"terminatingCharacter",REDUCE,36);
          actionTable(12,"union",REDUCE,36);
          actionTable(12,"satisfies",REDUCE,36);
          actionTable(12,"closingParenth",REDUCE,36);
          actionTable(12,"else",REDUCE,36);

          actionTable(13,"FunctionCall",SHIFT,18);
          actionTable(13,"openingParenth",SHIFT,6);
          actionTable(13,"PrimaryExpr",SHIFT,16);
          actionTable(13,"NumericLiteral",SHIFT,20);
          actionTable(13,"Literal",SHIFT,17);
          actionTable(13,"ParenthesizeExpr",SHIFT,19);
          actionTable(13,"name",SHIFT,4);
          actionTable(13,"digits",SHIFT,9);
          actionTable(13,"booleanFunc",SHIFT,5);
          actionTable(13,"StringLiteral",SHIFT,21);
          actionTable(13,"backslash",SHIFT,14);
          actionTable(13,"StepExpr",SHIFT,22);
          actionTable(13,"dollar",SHIFT,10);

          actionTable(14,"FunctionCall",SHIFT,18);
          actionTable(14,"openingParenth",SHIFT,6);
          actionTable(14,"PrimaryExpr",SHIFT,16);
          actionTable(14,"NumericLiteral",SHIFT,20);
          actionTable(14,"Literal",SHIFT,17);
          actionTable(14,"ParenthesizeExpr",SHIFT,19);
          actionTable(14,"name",SHIFT,4);
          actionTable(14,"digits",SHIFT,9);
          actionTable(14,"booleanFunc",SHIFT,5);
          actionTable(14,"StringLiteral",SHIFT,21);
          actionTable(14,"StepExpr",SHIFT,15);
          actionTable(14,"dollar",SHIFT,10);

          actionTable(15,"divide",REDUCE,39);
          actionTable(15,"multiply",REDUCE,39);
          actionTable(15,"subtract",REDUCE,39);
          actionTable(15,"add",REDUCE,39);
          actionTable(15,"comparison",REDUCE,39);
          actionTable(15,"and",REDUCE,39);
          actionTable(15,"or",REDUCE,39);
          actionTable(15,"terminatingCharacter",REDUCE,39);
          actionTable(15,"union",REDUCE,39);
          actionTable(15,"backslash",REDUCE,39);
          actionTable(15,"satisfies",REDUCE,39);
          actionTable(15,"closingParenth",REDUCE,39);
          actionTable(15,"else",REDUCE,39);

          actionTable(16,"divide",REDUCE,42);
          actionTable(16,"multiply",REDUCE,42);
          actionTable(16,"subtract",REDUCE,42);
          actionTable(16,"add",REDUCE,42);
          actionTable(16,"comparison",REDUCE,42);
          actionTable(16,"and",REDUCE,42);
          actionTable(16,"or",REDUCE,42);
          actionTable(16,"terminatingCharacter",REDUCE,42);
          actionTable(16,"union",REDUCE,42);
          actionTable(16,"backslash",REDUCE,42);
          actionTable(16,"satisfies",REDUCE,42);
          actionTable(16,"closingParenth",REDUCE,42);
          actionTable(16,"else",REDUCE,42);

          actionTable(17,"divide",REDUCE,44);
          actionTable(17,"multiply",REDUCE,44);
          actionTable(17,"subtract",REDUCE,44);
          actionTable(17,"add",REDUCE,44);
          actionTable(17,"comparison",REDUCE,44);
          actionTable(17,"and",REDUCE,44);
          actionTable(17,"or",REDUCE,44);
          actionTable(17,"terminatingCharacter",REDUCE,44);
          actionTable(17,"union",REDUCE,44);
          actionTable(17,"backslash",REDUCE,44);
          actionTable(17,"satisfies",REDUCE,44);
          actionTable(17,"closingParenth",REDUCE,44);
          actionTable(17,"else",REDUCE,44);

          actionTable(18,"divide",REDUCE,46);
          actionTable(18,"multiply",REDUCE,46);
          actionTable(18,"subtract",REDUCE,46);
          actionTable(18,"add",REDUCE,46);
          actionTable(18,"comparison",REDUCE,46);
          actionTable(18,"and",REDUCE,46);
          actionTable(18,"or",REDUCE,46);
          actionTable(18,"terminatingCharacter",REDUCE,46);
          actionTable(18,"union",REDUCE,46);
          actionTable(18,"backslash",REDUCE,46);
          actionTable(18,"satisfies",REDUCE,46);
          actionTable(18,"closingParenth",REDUCE,46);
          actionTable(18,"else",REDUCE,46);

          actionTable(19,"divide",REDUCE,45);
          actionTable(19,"multiply",REDUCE,45);
          actionTable(19,"subtract",REDUCE,45);
          actionTable(19,"add",REDUCE,45);
          actionTable(19,"comparison",REDUCE,45);
          actionTable(19,"and",REDUCE,45);
          actionTable(19,"or",REDUCE,45);
          actionTable(19,"terminatingCharacter",REDUCE,45);
          actionTable(19,"union",REDUCE,45);
          actionTable(19,"backslash",REDUCE,45);
          actionTable(19,"satisfies",REDUCE,45);
          actionTable(19,"closingParenth",REDUCE,45);
          actionTable(19,"else",REDUCE,45);

          actionTable(20,"divide",REDUCE,48);
          actionTable(20,"multiply",REDUCE,48);
          actionTable(20,"subtract",REDUCE,48);
          actionTable(20,"add",REDUCE,48);
          actionTable(20,"comparison",REDUCE,48);
          actionTable(20,"and",REDUCE,48);
          actionTable(20,"or",REDUCE,48);
          actionTable(20,"terminatingCharacter",REDUCE,48);
          actionTable(20,"union",REDUCE,48);
          actionTable(20,"backslash",REDUCE,48);
          actionTable(20,"satisfies",REDUCE,48);
          actionTable(20,"closingParenth",REDUCE,48);
          actionTable(20,"else",REDUCE,48);

          actionTable(21,"divide",REDUCE,47);
          actionTable(21,"multiply",REDUCE,47);
          actionTable(21,"subtract",REDUCE,47);
          actionTable(21,"add",REDUCE,47);
          actionTable(21,"comparison",REDUCE,47);
          actionTable(21,"and",REDUCE,47);
          actionTable(21,"or",REDUCE,47);
          actionTable(21,"terminatingCharacter",REDUCE,47);
          actionTable(21,"union",REDUCE,47);
          actionTable(21,"backslash",REDUCE,47);
          actionTable(21,"satisfies",REDUCE,47);
          actionTable(21,"closingParenth",REDUCE,47);
          actionTable(21,"else",REDUCE,47);

          actionTable(22,"divide",REDUCE,40);
          actionTable(22,"multiply",REDUCE,40);
          actionTable(22,"subtract",REDUCE,40);
          actionTable(22,"add",REDUCE,40);
          actionTable(22,"comparison",REDUCE,40);
          actionTable(22,"and",REDUCE,40);
          actionTable(22,"or",REDUCE,40);
          actionTable(22,"terminatingCharacter",REDUCE,40);
          actionTable(22,"union",REDUCE,40);
          actionTable(22,"backslash",REDUCE,40);
          actionTable(22,"satisfies",REDUCE,40);
          actionTable(22,"closingParenth",REDUCE,40);
          actionTable(22,"else",REDUCE,40);

          actionTable(23,"divide",REDUCE,41);
          actionTable(23,"multiply",REDUCE,41);
          actionTable(23,"subtract",REDUCE,41);
          actionTable(23,"add",REDUCE,41);
          actionTable(23,"comparison",REDUCE,41);
          actionTable(23,"and",REDUCE,41);
          actionTable(23,"or",REDUCE,41);
          actionTable(23,"terminatingCharacter",REDUCE,41);
          actionTable(23,"union",REDUCE,41);
          actionTable(23,"backslash",REDUCE,41);
          actionTable(23,"satisfies",REDUCE,41);
          actionTable(23,"closingParenth",REDUCE,41);
          actionTable(23,"else",REDUCE,41);

          actionTable(24,"backslash",SHIFT,13);
          actionTable(24,"divide",REDUCE,37);
          actionTable(24,"multiply",REDUCE,37);
          actionTable(24,"subtract",REDUCE,37);
          actionTable(24,"add",REDUCE,37);
          actionTable(24,"comparison",REDUCE,37);
          actionTable(24,"and",REDUCE,37);
          actionTable(24,"or",REDUCE,37);
          actionTable(24,"terminatingCharacter",REDUCE,37);
          actionTable(24,"union",REDUCE,37);
          actionTable(24,"satisfies",REDUCE,37);
          actionTable(24,"closingParenth",REDUCE,37);
          actionTable(24,"else",REDUCE,37);

          actionTable(25,"UnionExpr",SHIFT,28);
          actionTable(25,"StepExpr",SHIFT,23);
          actionTable(25,"FunctionCall",SHIFT,18);
          actionTable(25,"StringLiteral",SHIFT,21);
          actionTable(25,"NumericLiteral",SHIFT,20);
          actionTable(25,"Literal",SHIFT,17);
          actionTable(25,"ValueExpr",SHIFT,31);
          actionTable(25,"digits",SHIFT,9);
          actionTable(25,"PathExpr",SHIFT,32);
          actionTable(25,"PrimaryExpr",SHIFT,16);
          actionTable(25,"UnaryExpr",SHIFT,35);
          actionTable(25,"add",SHIFT,25);
          actionTable(25,"booleanFunc",SHIFT,5);
          actionTable(25,"name",SHIFT,4);
          actionTable(25,"subtract",SHIFT,26);
          actionTable(25,"RelativePathExpr",SHIFT,33);
          actionTable(25,"dollar",SHIFT,10);
          actionTable(25,"backslash",SHIFT,7);
          actionTable(25,"IntersectExceptExpr",SHIFT,34);
          actionTable(25,"ParenthesizeExpr",SHIFT,19);
          actionTable(25,"openingParenth",SHIFT,6);

          actionTable(26,"UnionExpr",SHIFT,28);
          actionTable(26,"StepExpr",SHIFT,23);
          actionTable(26,"FunctionCall",SHIFT,18);
          actionTable(26,"StringLiteral",SHIFT,21);
          actionTable(26,"NumericLiteral",SHIFT,20);
          actionTable(26,"Literal",SHIFT,17);
          actionTable(26,"ValueExpr",SHIFT,31);
          actionTable(26,"digits",SHIFT,9);
          actionTable(26,"PathExpr",SHIFT,32);
          actionTable(26,"PrimaryExpr",SHIFT,16);
          actionTable(26,"UnaryExpr",SHIFT,27);
          actionTable(26,"add",SHIFT,25);
          actionTable(26,"booleanFunc",SHIFT,5);
          actionTable(26,"name",SHIFT,4);
          actionTable(26,"subtract",SHIFT,26);
          actionTable(26,"RelativePathExpr",SHIFT,33);
          actionTable(26,"dollar",SHIFT,10);
          actionTable(26,"backslash",SHIFT,7);
          actionTable(26,"IntersectExceptExpr",SHIFT,34);
          actionTable(26,"ParenthesizeExpr",SHIFT,19);
          actionTable(26,"openingParenth",SHIFT,6);

          actionTable(27,"divide",REDUCE,29);
          actionTable(27,"multiply",REDUCE,29);
          actionTable(27,"subtract",REDUCE,29);
          actionTable(27,"add",REDUCE,29);
          actionTable(27,"comparison",REDUCE,29);
          actionTable(27,"and",REDUCE,29);
          actionTable(27,"or",REDUCE,29);
          actionTable(27,"terminatingCharacter",REDUCE,29);
          actionTable(27,"satisfies",REDUCE,29);
          actionTable(27,"closingParenth",REDUCE,29);
          actionTable(27,"else",REDUCE,29);

          actionTable(28,"union",SHIFT,29);
          actionTable(28,"divide",REDUCE,30);
          actionTable(28,"multiply",REDUCE,30);
          actionTable(28,"subtract",REDUCE,30);
          actionTable(28,"add",REDUCE,30);
          actionTable(28,"comparison",REDUCE,30);
          actionTable(28,"and",REDUCE,30);
          actionTable(28,"or",REDUCE,30);
          actionTable(28,"terminatingCharacter",REDUCE,30);
          actionTable(28,"satisfies",REDUCE,30);
          actionTable(28,"closingParenth",REDUCE,30);
          actionTable(28,"else",REDUCE,30);

          actionTable(29,"StepExpr",SHIFT,23);
          actionTable(29,"FunctionCall",SHIFT,18);
          actionTable(29,"StringLiteral",SHIFT,21);
          actionTable(29,"NumericLiteral",SHIFT,20);
          actionTable(29,"Literal",SHIFT,17);
          actionTable(29,"ValueExpr",SHIFT,31);
          actionTable(29,"digits",SHIFT,9);
          actionTable(29,"PathExpr",SHIFT,32);
          actionTable(29,"PrimaryExpr",SHIFT,16);
          actionTable(29,"booleanFunc",SHIFT,5);
          actionTable(29,"name",SHIFT,4);
          actionTable(29,"RelativePathExpr",SHIFT,33);
          actionTable(29,"dollar",SHIFT,10);
          actionTable(29,"backslash",SHIFT,7);
          actionTable(29,"IntersectExceptExpr",SHIFT,30);
          actionTable(29,"ParenthesizeExpr",SHIFT,19);
          actionTable(29,"openingParenth",SHIFT,6);

          actionTable(30,"divide",REDUCE,31);
          actionTable(30,"multiply",REDUCE,31);
          actionTable(30,"subtract",REDUCE,31);
          actionTable(30,"add",REDUCE,31);
          actionTable(30,"comparison",REDUCE,31);
          actionTable(30,"and",REDUCE,31);
          actionTable(30,"or",REDUCE,31);
          actionTable(30,"terminatingCharacter",REDUCE,31);
          actionTable(30,"union",REDUCE,31);
          actionTable(30,"satisfies",REDUCE,31);
          actionTable(30,"closingParenth",REDUCE,31);
          actionTable(30,"else",REDUCE,31);

          actionTable(31,"divide",REDUCE,33);
          actionTable(31,"multiply",REDUCE,33);
          actionTable(31,"subtract",REDUCE,33);
          actionTable(31,"add",REDUCE,33);
          actionTable(31,"comparison",REDUCE,33);
          actionTable(31,"and",REDUCE,33);
          actionTable(31,"or",REDUCE,33);
          actionTable(31,"terminatingCharacter",REDUCE,33);
          actionTable(31,"union",REDUCE,33);
          actionTable(31,"satisfies",REDUCE,33);
          actionTable(31,"closingParenth",REDUCE,33);
          actionTable(31,"else",REDUCE,33);

          actionTable(32,"divide",REDUCE,34);
          actionTable(32,"multiply",REDUCE,34);
          actionTable(32,"subtract",REDUCE,34);
          actionTable(32,"add",REDUCE,34);
          actionTable(32,"comparison",REDUCE,34);
          actionTable(32,"and",REDUCE,34);
          actionTable(32,"or",REDUCE,34);
          actionTable(32,"terminatingCharacter",REDUCE,34);
          actionTable(32,"union",REDUCE,34);
          actionTable(32,"satisfies",REDUCE,34);
          actionTable(32,"closingParenth",REDUCE,34);
          actionTable(32,"else",REDUCE,34);

          actionTable(33,"backslash",SHIFT,13);
          actionTable(33,"divide",REDUCE,35);
          actionTable(33,"multiply",REDUCE,35);
          actionTable(33,"subtract",REDUCE,35);
          actionTable(33,"add",REDUCE,35);
          actionTable(33,"comparison",REDUCE,35);
          actionTable(33,"and",REDUCE,35);
          actionTable(33,"or",REDUCE,35);
          actionTable(33,"terminatingCharacter",REDUCE,35);
          actionTable(33,"union",REDUCE,35);
          actionTable(33,"satisfies",REDUCE,35);
          actionTable(33,"closingParenth",REDUCE,35);
          actionTable(33,"else",REDUCE,35);

          actionTable(34,"divide",REDUCE,32);
          actionTable(34,"multiply",REDUCE,32);
          actionTable(34,"subtract",REDUCE,32);
          actionTable(34,"add",REDUCE,32);
          actionTable(34,"comparison",REDUCE,32);
          actionTable(34,"and",REDUCE,32);
          actionTable(34,"or",REDUCE,32);
          actionTable(34,"terminatingCharacter",REDUCE,32);
          actionTable(34,"union",REDUCE,32);
          actionTable(34,"satisfies",REDUCE,32);
          actionTable(34,"closingParenth",REDUCE,32);
          actionTable(34,"else",REDUCE,32);

          actionTable(35,"divide",REDUCE,28);
          actionTable(35,"multiply",REDUCE,28);
          actionTable(35,"subtract",REDUCE,28);
          actionTable(35,"add",REDUCE,28);
          actionTable(35,"comparison",REDUCE,28);
          actionTable(35,"and",REDUCE,28);
          actionTable(35,"or",REDUCE,28);
          actionTable(35,"terminatingCharacter",REDUCE,28);
          actionTable(35,"satisfies",REDUCE,28);
          actionTable(35,"closingParenth",REDUCE,28);
          actionTable(35,"else",REDUCE,28);

          actionTable(36,"dollar",SHIFT,37);

          actionTable(37,"name",SHIFT,38);

          actionTable(38,"in",SHIFT,39);

          actionTable(39,"Literal",SHIFT,17);
          actionTable(39,"openingParenth",SHIFT,6);
          actionTable(39,"ValueExpr",SHIFT,31);
          actionTable(39,"CastableExpr",SHIFT,55);
          actionTable(39,"UnionExpr",SHIFT,28);
          actionTable(39,"PrimaryExpr",SHIFT,16);
          actionTable(39,"IntersectExceptExpr",SHIFT,34);
          actionTable(39,"some",SHIFT,40);
          actionTable(39,"IfExpr",SHIFT,53);
          actionTable(39,"digits",SHIFT,9);
          actionTable(39,"RangeExpr",SHIFT,57);
          actionTable(39,"RelativePathExpr",SHIFT,33);
          actionTable(39,"StepExpr",SHIFT,23);
          actionTable(39,"add",SHIFT,25);
          actionTable(39,"NumericLiteral",SHIFT,20);
          actionTable(39,"Expr",SHIFT,80);
          actionTable(39,"QuantifiedExpr",SHIFT,52);
          actionTable(39,"every",SHIFT,36);
          actionTable(39,"dollar",SHIFT,10);
          actionTable(39,"InstanceOfExpr",SHIFT,54);
          actionTable(39,"not",SHIFT,44);
          actionTable(39,"if",SHIFT,2);
          actionTable(39,"AdditiveExpr",SHIFT,60);
          actionTable(39,"ForExpr",SHIFT,49);
          actionTable(39,"ComparisonExpr",SHIFT,56);
          actionTable(39,"FunctionCall",SHIFT,18);
          actionTable(39,"ParenthesizeExpr",SHIFT,75);
          actionTable(39,"PathExpr",SHIFT,32);
          actionTable(39,"subtract",SHIFT,26);
          actionTable(39,"UnaryExpr",SHIFT,64);
          actionTable(39,"backslash",SHIFT,7);
          actionTable(39,"booleanFunc",SHIFT,5);
          actionTable(39,"StringLiteral",SHIFT,21);
          actionTable(39,"name",SHIFT,4);
          actionTable(39,"OrExpr",SHIFT,74);
          actionTable(39,"MultiplicativeExpr",SHIFT,61);
          actionTable(39,"AndExpr",SHIFT,46);

          actionTable(40,"dollar",SHIFT,41);

          actionTable(41,"name",SHIFT,42);

          actionTable(42,"in",SHIFT,43);

          actionTable(43,"Literal",SHIFT,17);
          actionTable(43,"openingParenth",SHIFT,6);
          actionTable(43,"ValueExpr",SHIFT,31);
          actionTable(43,"CastableExpr",SHIFT,55);
          actionTable(43,"UnionExpr",SHIFT,28);
          actionTable(43,"PrimaryExpr",SHIFT,16);
          actionTable(43,"IntersectExceptExpr",SHIFT,34);
          actionTable(43,"some",SHIFT,40);
          actionTable(43,"IfExpr",SHIFT,53);
          actionTable(43,"digits",SHIFT,9);
          actionTable(43,"RangeExpr",SHIFT,57);
          actionTable(43,"RelativePathExpr",SHIFT,33);
          actionTable(43,"StepExpr",SHIFT,23);
          actionTable(43,"add",SHIFT,25);
          actionTable(43,"NumericLiteral",SHIFT,20);
          actionTable(43,"Expr",SHIFT,71);
          actionTable(43,"QuantifiedExpr",SHIFT,52);
          actionTable(43,"every",SHIFT,36);
          actionTable(43,"dollar",SHIFT,10);
          actionTable(43,"InstanceOfExpr",SHIFT,54);
          actionTable(43,"not",SHIFT,44);
          actionTable(43,"if",SHIFT,2);
          actionTable(43,"AdditiveExpr",SHIFT,60);
          actionTable(43,"ForExpr",SHIFT,49);
          actionTable(43,"ComparisonExpr",SHIFT,56);
          actionTable(43,"FunctionCall",SHIFT,18);
          actionTable(43,"ParenthesizeExpr",SHIFT,75);
          actionTable(43,"PathExpr",SHIFT,32);
          actionTable(43,"subtract",SHIFT,26);
          actionTable(43,"UnaryExpr",SHIFT,64);
          actionTable(43,"backslash",SHIFT,7);
          actionTable(43,"booleanFunc",SHIFT,5);
          actionTable(43,"StringLiteral",SHIFT,21);
          actionTable(43,"name",SHIFT,4);
          actionTable(43,"OrExpr",SHIFT,74);
          actionTable(43,"MultiplicativeExpr",SHIFT,61);
          actionTable(43,"AndExpr",SHIFT,46);

          actionTable(44,"Literal",SHIFT,17);
          actionTable(44,"openingParenth",SHIFT,6);
          actionTable(44,"ValueExpr",SHIFT,31);
          actionTable(44,"CastableExpr",SHIFT,55);
          actionTable(44,"UnionExpr",SHIFT,28);
          actionTable(44,"PrimaryExpr",SHIFT,16);
          actionTable(44,"IntersectExceptExpr",SHIFT,34);
          actionTable(44,"some",SHIFT,40);
          actionTable(44,"IfExpr",SHIFT,53);
          actionTable(44,"digits",SHIFT,9);
          actionTable(44,"RangeExpr",SHIFT,57);
          actionTable(44,"RelativePathExpr",SHIFT,33);
          actionTable(44,"StepExpr",SHIFT,23);
          actionTable(44,"add",SHIFT,25);
          actionTable(44,"NumericLiteral",SHIFT,20);
          actionTable(44,"QuantifiedExpr",SHIFT,52);
          actionTable(44,"every",SHIFT,36);
          actionTable(44,"dollar",SHIFT,10);
          actionTable(44,"InstanceOfExpr",SHIFT,54);
          actionTable(44,"if",SHIFT,2);
          actionTable(44,"AdditiveExpr",SHIFT,60);
          actionTable(44,"ForExpr",SHIFT,49);
          actionTable(44,"ComparisonExpr",SHIFT,56);
          actionTable(44,"FunctionCall",SHIFT,18);
          actionTable(44,"ParenthesizeExpr",SHIFT,19);
          actionTable(44,"PathExpr",SHIFT,32);
          actionTable(44,"subtract",SHIFT,26);
          actionTable(44,"UnaryExpr",SHIFT,64);
          actionTable(44,"backslash",SHIFT,7);
          actionTable(44,"booleanFunc",SHIFT,5);
          actionTable(44,"StringLiteral",SHIFT,21);
          actionTable(44,"name",SHIFT,4);
          actionTable(44,"OrExpr",SHIFT,45);
          actionTable(44,"MultiplicativeExpr",SHIFT,61);
          actionTable(44,"AndExpr",SHIFT,46);

          actionTable(45,"terminatingCharacter",REDUCE,5);
          actionTable(45,"satisfies",REDUCE,5);
          actionTable(45,"closingParenth",REDUCE,5);
          actionTable(45,"else",REDUCE,5);

          actionTable(46,"or",SHIFT,47);
          actionTable(46,"terminatingCharacter",REDUCE,8);
          actionTable(46,"satisfies",REDUCE,8);
          actionTable(46,"closingParenth",REDUCE,8);
          actionTable(46,"else",REDUCE,8);

          actionTable(47,"Literal",SHIFT,17);
          actionTable(47,"openingParenth",SHIFT,6);
          actionTable(47,"ValueExpr",SHIFT,31);
          actionTable(47,"CastableExpr",SHIFT,55);
          actionTable(47,"UnionExpr",SHIFT,28);
          actionTable(47,"PrimaryExpr",SHIFT,16);
          actionTable(47,"IntersectExceptExpr",SHIFT,34);
          actionTable(47,"some",SHIFT,40);
          actionTable(47,"IfExpr",SHIFT,53);
          actionTable(47,"digits",SHIFT,9);
          actionTable(47,"RangeExpr",SHIFT,57);
          actionTable(47,"RelativePathExpr",SHIFT,33);
          actionTable(47,"StepExpr",SHIFT,23);
          actionTable(47,"add",SHIFT,25);
          actionTable(47,"NumericLiteral",SHIFT,20);
          actionTable(47,"QuantifiedExpr",SHIFT,52);
          actionTable(47,"every",SHIFT,36);
          actionTable(47,"dollar",SHIFT,10);
          actionTable(47,"InstanceOfExpr",SHIFT,54);
          actionTable(47,"if",SHIFT,2);
          actionTable(47,"AdditiveExpr",SHIFT,60);
          actionTable(47,"ForExpr",SHIFT,49);
          actionTable(47,"ComparisonExpr",SHIFT,56);
          actionTable(47,"FunctionCall",SHIFT,18);
          actionTable(47,"ParenthesizeExpr",SHIFT,19);
          actionTable(47,"PathExpr",SHIFT,32);
          actionTable(47,"subtract",SHIFT,26);
          actionTable(47,"UnaryExpr",SHIFT,64);
          actionTable(47,"backslash",SHIFT,7);
          actionTable(47,"booleanFunc",SHIFT,5);
          actionTable(47,"StringLiteral",SHIFT,21);
          actionTable(47,"name",SHIFT,4);
          actionTable(47,"OrExpr",SHIFT,48);
          actionTable(47,"MultiplicativeExpr",SHIFT,61);
          actionTable(47,"AndExpr",SHIFT,46);

          actionTable(48,"terminatingCharacter",REDUCE,7);
          actionTable(48,"satisfies",REDUCE,7);
          actionTable(48,"closingParenth",REDUCE,7);
          actionTable(48,"else",REDUCE,7);

          actionTable(49,"and",SHIFT,50);
          actionTable(49,"or",REDUCE,10);
          actionTable(49,"terminatingCharacter",REDUCE,10);
          actionTable(49,"satisfies",REDUCE,10);
          actionTable(49,"closingParenth",REDUCE,10);
          actionTable(49,"else",REDUCE,10);

          actionTable(50,"Literal",SHIFT,17);
          actionTable(50,"openingParenth",SHIFT,6);
          actionTable(50,"ValueExpr",SHIFT,31);
          actionTable(50,"CastableExpr",SHIFT,55);
          actionTable(50,"UnionExpr",SHIFT,28);
          actionTable(50,"PrimaryExpr",SHIFT,16);
          actionTable(50,"IntersectExceptExpr",SHIFT,34);
          actionTable(50,"some",SHIFT,40);
          actionTable(50,"IfExpr",SHIFT,53);
          actionTable(50,"digits",SHIFT,9);
          actionTable(50,"RangeExpr",SHIFT,57);
          actionTable(50,"RelativePathExpr",SHIFT,33);
          actionTable(50,"StepExpr",SHIFT,23);
          actionTable(50,"add",SHIFT,25);
          actionTable(50,"NumericLiteral",SHIFT,20);
          actionTable(50,"QuantifiedExpr",SHIFT,52);
          actionTable(50,"every",SHIFT,36);
          actionTable(50,"dollar",SHIFT,10);
          actionTable(50,"InstanceOfExpr",SHIFT,54);
          actionTable(50,"if",SHIFT,2);
          actionTable(50,"AdditiveExpr",SHIFT,60);
          actionTable(50,"ForExpr",SHIFT,49);
          actionTable(50,"ComparisonExpr",SHIFT,56);
          actionTable(50,"FunctionCall",SHIFT,18);
          actionTable(50,"ParenthesizeExpr",SHIFT,19);
          actionTable(50,"PathExpr",SHIFT,32);
          actionTable(50,"subtract",SHIFT,26);
          actionTable(50,"UnaryExpr",SHIFT,64);
          actionTable(50,"backslash",SHIFT,7);
          actionTable(50,"booleanFunc",SHIFT,5);
          actionTable(50,"StringLiteral",SHIFT,21);
          actionTable(50,"name",SHIFT,4);
          actionTable(50,"MultiplicativeExpr",SHIFT,61);
          actionTable(50,"AndExpr",SHIFT,51);

          actionTable(51,"or",REDUCE,9);
          actionTable(51,"terminatingCharacter",REDUCE,9);
          actionTable(51,"satisfies",REDUCE,9);
          actionTable(51,"closingParenth",REDUCE,9);
          actionTable(51,"else",REDUCE,9);

          actionTable(52,"and",REDUCE,11);
          actionTable(52,"or",REDUCE,11);
          actionTable(52,"terminatingCharacter",REDUCE,11);
          actionTable(52,"satisfies",REDUCE,11);
          actionTable(52,"closingParenth",REDUCE,11);
          actionTable(52,"else",REDUCE,11);

          actionTable(53,"and",REDUCE,14);
          actionTable(53,"or",REDUCE,14);
          actionTable(53,"terminatingCharacter",REDUCE,14);
          actionTable(53,"satisfies",REDUCE,14);
          actionTable(53,"closingParenth",REDUCE,14);
          actionTable(53,"else",REDUCE,14);

          actionTable(54,"and",REDUCE,16);
          actionTable(54,"or",REDUCE,16);
          actionTable(54,"terminatingCharacter",REDUCE,16);
          actionTable(54,"satisfies",REDUCE,16);
          actionTable(54,"closingParenth",REDUCE,16);
          actionTable(54,"else",REDUCE,16);

          actionTable(55,"and",REDUCE,17);
          actionTable(55,"or",REDUCE,17);
          actionTable(55,"terminatingCharacter",REDUCE,17);
          actionTable(55,"satisfies",REDUCE,17);
          actionTable(55,"closingParenth",REDUCE,17);
          actionTable(55,"else",REDUCE,17);

          actionTable(56,"and",REDUCE,18);
          actionTable(56,"or",REDUCE,18);
          actionTable(56,"terminatingCharacter",REDUCE,18);
          actionTable(56,"satisfies",REDUCE,18);
          actionTable(56,"closingParenth",REDUCE,18);
          actionTable(56,"else",REDUCE,18);

          actionTable(57,"comparison",SHIFT,58);
          actionTable(57,"and",REDUCE,20);
          actionTable(57,"or",REDUCE,20);
          actionTable(57,"terminatingCharacter",REDUCE,20);
          actionTable(57,"satisfies",REDUCE,20);
          actionTable(57,"closingParenth",REDUCE,20);
          actionTable(57,"else",REDUCE,20);

          actionTable(58,"StepExpr",SHIFT,23);
          actionTable(58,"UnionExpr",SHIFT,28);
          actionTable(58,"FunctionCall",SHIFT,18);
          actionTable(58,"StringLiteral",SHIFT,21);
          actionTable(58,"NumericLiteral",SHIFT,20);
          actionTable(58,"Literal",SHIFT,17);
          actionTable(58,"ValueExpr",SHIFT,31);
          actionTable(58,"PathExpr",SHIFT,32);
          actionTable(58,"digits",SHIFT,9);
          actionTable(58,"PrimaryExpr",SHIFT,16);
          actionTable(58,"UnaryExpr",SHIFT,64);
          actionTable(58,"add",SHIFT,25);
          actionTable(58,"booleanFunc",SHIFT,5);
          actionTable(58,"RangeExpr",SHIFT,59);
          actionTable(58,"name",SHIFT,4);
          actionTable(58,"MultiplicativeExpr",SHIFT,61);
          actionTable(58,"subtract",SHIFT,26);
          actionTable(58,"RelativePathExpr",SHIFT,33);
          actionTable(58,"AdditiveExpr",SHIFT,60);
          actionTable(58,"dollar",SHIFT,10);
          actionTable(58,"backslash",SHIFT,7);
          actionTable(58,"IntersectExceptExpr",SHIFT,34);
          actionTable(58,"ParenthesizeExpr",SHIFT,19);
          actionTable(58,"openingParenth",SHIFT,6);

          actionTable(59,"and",REDUCE,19);
          actionTable(59,"or",REDUCE,19);
          actionTable(59,"terminatingCharacter",REDUCE,19);
          actionTable(59,"satisfies",REDUCE,19);
          actionTable(59,"closingParenth",REDUCE,19);
          actionTable(59,"else",REDUCE,19);

          actionTable(60,"comparison",REDUCE,21);
          actionTable(60,"and",REDUCE,21);
          actionTable(60,"or",REDUCE,21);
          actionTable(60,"terminatingCharacter",REDUCE,21);
          actionTable(60,"satisfies",REDUCE,21);
          actionTable(60,"closingParenth",REDUCE,21);
          actionTable(60,"else",REDUCE,21);

          actionTable(61,"add",SHIFT,62);
          actionTable(61,"subtract",SHIFT,69);
          actionTable(61,"comparison",REDUCE,24);
          actionTable(61,"and",REDUCE,24);
          actionTable(61,"or",REDUCE,24);
          actionTable(61,"terminatingCharacter",REDUCE,24);
          actionTable(61,"satisfies",REDUCE,24);
          actionTable(61,"closingParenth",REDUCE,24);
          actionTable(61,"else",REDUCE,24);

          actionTable(62,"StepExpr",SHIFT,23);
          actionTable(62,"UnionExpr",SHIFT,28);
          actionTable(62,"FunctionCall",SHIFT,18);
          actionTable(62,"StringLiteral",SHIFT,21);
          actionTable(62,"NumericLiteral",SHIFT,20);
          actionTable(62,"Literal",SHIFT,17);
          actionTable(62,"ValueExpr",SHIFT,31);
          actionTable(62,"digits",SHIFT,9);
          actionTable(62,"PathExpr",SHIFT,32);
          actionTable(62,"PrimaryExpr",SHIFT,16);
          actionTable(62,"UnaryExpr",SHIFT,64);
          actionTable(62,"add",SHIFT,25);
          actionTable(62,"booleanFunc",SHIFT,5);
          actionTable(62,"name",SHIFT,4);
          actionTable(62,"MultiplicativeExpr",SHIFT,61);
          actionTable(62,"subtract",SHIFT,26);
          actionTable(62,"RelativePathExpr",SHIFT,33);
          actionTable(62,"AdditiveExpr",SHIFT,63);
          actionTable(62,"dollar",SHIFT,10);
          actionTable(62,"backslash",SHIFT,7);
          actionTable(62,"IntersectExceptExpr",SHIFT,34);
          actionTable(62,"ParenthesizeExpr",SHIFT,19);
          actionTable(62,"openingParenth",SHIFT,6);

          actionTable(63,"comparison",REDUCE,23);
          actionTable(63,"and",REDUCE,23);
          actionTable(63,"or",REDUCE,23);
          actionTable(63,"terminatingCharacter",REDUCE,23);
          actionTable(63,"satisfies",REDUCE,23);
          actionTable(63,"closingParenth",REDUCE,23);
          actionTable(63,"else",REDUCE,23);

          actionTable(64,"multiply",SHIFT,65);
          actionTable(64,"divide",SHIFT,67);
          actionTable(64,"subtract",REDUCE,27);
          actionTable(64,"add",REDUCE,27);
          actionTable(64,"comparison",REDUCE,27);
          actionTable(64,"and",REDUCE,27);
          actionTable(64,"or",REDUCE,27);
          actionTable(64,"terminatingCharacter",REDUCE,27);
          actionTable(64,"satisfies",REDUCE,27);
          actionTable(64,"closingParenth",REDUCE,27);
          actionTable(64,"else",REDUCE,27);

          actionTable(65,"StepExpr",SHIFT,23);
          actionTable(65,"UnionExpr",SHIFT,28);
          actionTable(65,"FunctionCall",SHIFT,18);
          actionTable(65,"StringLiteral",SHIFT,21);
          actionTable(65,"NumericLiteral",SHIFT,20);
          actionTable(65,"Literal",SHIFT,17);
          actionTable(65,"ValueExpr",SHIFT,31);
          actionTable(65,"digits",SHIFT,9);
          actionTable(65,"PathExpr",SHIFT,32);
          actionTable(65,"PrimaryExpr",SHIFT,16);
          actionTable(65,"UnaryExpr",SHIFT,64);
          actionTable(65,"add",SHIFT,25);
          actionTable(65,"booleanFunc",SHIFT,5);
          actionTable(65,"name",SHIFT,4);
          actionTable(65,"MultiplicativeExpr",SHIFT,66);
          actionTable(65,"subtract",SHIFT,26);
          actionTable(65,"RelativePathExpr",SHIFT,33);
          actionTable(65,"dollar",SHIFT,10);
          actionTable(65,"backslash",SHIFT,7);
          actionTable(65,"IntersectExceptExpr",SHIFT,34);
          actionTable(65,"ParenthesizeExpr",SHIFT,19);
          actionTable(65,"openingParenth",SHIFT,6);

          actionTable(66,"subtract",REDUCE,26);
          actionTable(66,"add",REDUCE,26);
          actionTable(66,"comparison",REDUCE,26);
          actionTable(66,"and",REDUCE,26);
          actionTable(66,"or",REDUCE,26);
          actionTable(66,"terminatingCharacter",REDUCE,26);
          actionTable(66,"satisfies",REDUCE,26);
          actionTable(66,"closingParenth",REDUCE,26);
          actionTable(66,"else",REDUCE,26);

          actionTable(67,"StepExpr",SHIFT,23);
          actionTable(67,"UnionExpr",SHIFT,28);
          actionTable(67,"FunctionCall",SHIFT,18);
          actionTable(67,"StringLiteral",SHIFT,21);
          actionTable(67,"NumericLiteral",SHIFT,20);
          actionTable(67,"Literal",SHIFT,17);
          actionTable(67,"ValueExpr",SHIFT,31);
          actionTable(67,"digits",SHIFT,9);
          actionTable(67,"PathExpr",SHIFT,32);
          actionTable(67,"PrimaryExpr",SHIFT,16);
          actionTable(67,"UnaryExpr",SHIFT,64);
          actionTable(67,"add",SHIFT,25);
          actionTable(67,"booleanFunc",SHIFT,5);
          actionTable(67,"name",SHIFT,4);
          actionTable(67,"MultiplicativeExpr",SHIFT,68);
          actionTable(67,"subtract",SHIFT,26);
          actionTable(67,"RelativePathExpr",SHIFT,33);
          actionTable(67,"dollar",SHIFT,10);
          actionTable(67,"backslash",SHIFT,7);
          actionTable(67,"IntersectExceptExpr",SHIFT,34);
          actionTable(67,"ParenthesizeExpr",SHIFT,19);
          actionTable(67,"openingParenth",SHIFT,6);

          actionTable(68,"subtract",REDUCE,25);
          actionTable(68,"add",REDUCE,25);
          actionTable(68,"comparison",REDUCE,25);
          actionTable(68,"and",REDUCE,25);
          actionTable(68,"or",REDUCE,25);
          actionTable(68,"terminatingCharacter",REDUCE,25);
          actionTable(68,"satisfies",REDUCE,25);
          actionTable(68,"closingParenth",REDUCE,25);
          actionTable(68,"else",REDUCE,25);

          actionTable(69,"StepExpr",SHIFT,23);
          actionTable(69,"UnionExpr",SHIFT,28);
          actionTable(69,"FunctionCall",SHIFT,18);
          actionTable(69,"StringLiteral",SHIFT,21);
          actionTable(69,"NumericLiteral",SHIFT,20);
          actionTable(69,"Literal",SHIFT,17);
          actionTable(69,"ValueExpr",SHIFT,31);
          actionTable(69,"digits",SHIFT,9);
          actionTable(69,"PathExpr",SHIFT,32);
          actionTable(69,"PrimaryExpr",SHIFT,16);
          actionTable(69,"UnaryExpr",SHIFT,64);
          actionTable(69,"add",SHIFT,25);
          actionTable(69,"booleanFunc",SHIFT,5);
          actionTable(69,"name",SHIFT,4);
          actionTable(69,"MultiplicativeExpr",SHIFT,61);
          actionTable(69,"subtract",SHIFT,26);
          actionTable(69,"RelativePathExpr",SHIFT,33);
          actionTable(69,"AdditiveExpr",SHIFT,70);
          actionTable(69,"dollar",SHIFT,10);
          actionTable(69,"backslash",SHIFT,7);
          actionTable(69,"IntersectExceptExpr",SHIFT,34);
          actionTable(69,"ParenthesizeExpr",SHIFT,19);
          actionTable(69,"openingParenth",SHIFT,6);

          actionTable(70,"comparison",REDUCE,22);
          actionTable(70,"and",REDUCE,22);
          actionTable(70,"or",REDUCE,22);
          actionTable(70,"terminatingCharacter",REDUCE,22);
          actionTable(70,"satisfies",REDUCE,22);
          actionTable(70,"closingParenth",REDUCE,22);
          actionTable(70,"else",REDUCE,22);

          actionTable(71,"satisfies",SHIFT,72);

          actionTable(72,"Literal",SHIFT,17);
          actionTable(72,"openingParenth",SHIFT,6);
          actionTable(72,"ValueExpr",SHIFT,31);
          actionTable(72,"CastableExpr",SHIFT,55);
          actionTable(72,"UnionExpr",SHIFT,28);
          actionTable(72,"PrimaryExpr",SHIFT,16);
          actionTable(72,"IntersectExceptExpr",SHIFT,34);
          actionTable(72,"some",SHIFT,40);
          actionTable(72,"IfExpr",SHIFT,53);
          actionTable(72,"digits",SHIFT,9);
          actionTable(72,"RangeExpr",SHIFT,57);
          actionTable(72,"RelativePathExpr",SHIFT,33);
          actionTable(72,"StepExpr",SHIFT,23);
          actionTable(72,"add",SHIFT,25);
          actionTable(72,"NumericLiteral",SHIFT,20);
          actionTable(72,"QuantifiedExpr",SHIFT,73);
          actionTable(72,"every",SHIFT,36);
          actionTable(72,"dollar",SHIFT,10);
          actionTable(72,"InstanceOfExpr",SHIFT,54);
          actionTable(72,"if",SHIFT,2);
          actionTable(72,"AdditiveExpr",SHIFT,60);
          actionTable(72,"ComparisonExpr",SHIFT,56);
          actionTable(72,"FunctionCall",SHIFT,18);
          actionTable(72,"ParenthesizeExpr",SHIFT,19);
          actionTable(72,"PathExpr",SHIFT,32);
          actionTable(72,"subtract",SHIFT,26);
          actionTable(72,"UnaryExpr",SHIFT,64);
          actionTable(72,"backslash",SHIFT,7);
          actionTable(72,"booleanFunc",SHIFT,5);
          actionTable(72,"StringLiteral",SHIFT,21);
          actionTable(72,"name",SHIFT,4);
          actionTable(72,"MultiplicativeExpr",SHIFT,61);

          actionTable(73,"and",REDUCE,13);
          actionTable(73,"or",REDUCE,13);
          actionTable(73,"terminatingCharacter",REDUCE,13);
          actionTable(73,"satisfies",REDUCE,13);
          actionTable(73,"closingParenth",REDUCE,13);
          actionTable(73,"else",REDUCE,13);

          actionTable(74,"terminatingCharacter",REDUCE,6);
          actionTable(74,"satisfies",REDUCE,6);
          actionTable(74,"closingParenth",REDUCE,6);
          actionTable(74,"else",REDUCE,6);

          actionTable(75,"equivalence",SHIFT,78);
          actionTable(75,"implication",SHIFT,76);
          actionTable(75,"divide",REDUCE,45);
          actionTable(75,"multiply",REDUCE,45);
          actionTable(75,"subtract",REDUCE,45);
          actionTable(75,"add",REDUCE,45);
          actionTable(75,"comparison",REDUCE,45);
          actionTable(75,"and",REDUCE,45);
          actionTable(75,"or",REDUCE,45);
          actionTable(75,"terminatingCharacter",REDUCE,45);
          actionTable(75,"union",REDUCE,45);
          actionTable(75,"backslash",REDUCE,45);
          actionTable(75,"satisfies",REDUCE,45);
          actionTable(75,"closingParenth",REDUCE,45);
          actionTable(75,"else",REDUCE,45);

          actionTable(76,"openingParenth",SHIFT,6);
          actionTable(76,"ParenthesizeExpr",SHIFT,77);

          actionTable(77,"terminatingCharacter",REDUCE,4);
          actionTable(77,"satisfies",REDUCE,4);
          actionTable(77,"closingParenth",REDUCE,4);
          actionTable(77,"else",REDUCE,4);

          actionTable(78,"openingParenth",SHIFT,6);
          actionTable(78,"ParenthesizeExpr",SHIFT,79);

          actionTable(79,"terminatingCharacter",REDUCE,3);
          actionTable(79,"satisfies",REDUCE,3);
          actionTable(79,"closingParenth",REDUCE,3);
          actionTable(79,"else",REDUCE,3);

          actionTable(80,"satisfies",SHIFT,81);

          actionTable(81,"Literal",SHIFT,17);
          actionTable(81,"openingParenth",SHIFT,6);
          actionTable(81,"ValueExpr",SHIFT,31);
          actionTable(81,"CastableExpr",SHIFT,55);
          actionTable(81,"UnionExpr",SHIFT,28);
          actionTable(81,"PrimaryExpr",SHIFT,16);
          actionTable(81,"IntersectExceptExpr",SHIFT,34);
          actionTable(81,"some",SHIFT,40);
          actionTable(81,"IfExpr",SHIFT,53);
          actionTable(81,"digits",SHIFT,9);
          actionTable(81,"RangeExpr",SHIFT,57);
          actionTable(81,"RelativePathExpr",SHIFT,33);
          actionTable(81,"StepExpr",SHIFT,23);
          actionTable(81,"add",SHIFT,25);
          actionTable(81,"NumericLiteral",SHIFT,20);
          actionTable(81,"QuantifiedExpr",SHIFT,82);
          actionTable(81,"every",SHIFT,36);
          actionTable(81,"dollar",SHIFT,10);
          actionTable(81,"InstanceOfExpr",SHIFT,54);
          actionTable(81,"if",SHIFT,2);
          actionTable(81,"AdditiveExpr",SHIFT,60);
          actionTable(81,"ComparisonExpr",SHIFT,56);
          actionTable(81,"FunctionCall",SHIFT,18);
          actionTable(81,"ParenthesizeExpr",SHIFT,19);
          actionTable(81,"PathExpr",SHIFT,32);
          actionTable(81,"subtract",SHIFT,26);
          actionTable(81,"UnaryExpr",SHIFT,64);
          actionTable(81,"backslash",SHIFT,7);
          actionTable(81,"booleanFunc",SHIFT,5);
          actionTable(81,"StringLiteral",SHIFT,21);
          actionTable(81,"name",SHIFT,4);
          actionTable(81,"MultiplicativeExpr",SHIFT,61);

          actionTable(82,"and",REDUCE,12);
          actionTable(82,"or",REDUCE,12);
          actionTable(82,"terminatingCharacter",REDUCE,12);
          actionTable(82,"satisfies",REDUCE,12);
          actionTable(82,"closingParenth",REDUCE,12);
          actionTable(82,"else",REDUCE,12);

          actionTable(83,"closingParenth",SHIFT,84);

          actionTable(84,"equivalence",REDUCE,50);
          actionTable(84,"terminatingCharacter",REDUCE,50);
          actionTable(84,"implication",REDUCE,50);
          actionTable(84,"divide",REDUCE,50);
          actionTable(84,"multiply",REDUCE,50);
          actionTable(84,"subtract",REDUCE,50);
          actionTable(84,"add",REDUCE,50);
          actionTable(84,"comparison",REDUCE,50);
          actionTable(84,"and",REDUCE,50);
          actionTable(84,"or",REDUCE,50);
          actionTable(84,"union",REDUCE,50);
          actionTable(84,"backslash",REDUCE,50);
          actionTable(84,"satisfies",REDUCE,50);
          actionTable(84,"closingParenth",REDUCE,50);
          actionTable(84,"else",REDUCE,50);

          actionTable(85,"closingParenth",SHIFT,86);

          actionTable(86,"then",SHIFT,87);

          actionTable(87,"Literal",SHIFT,17);
          actionTable(87,"openingParenth",SHIFT,6);
          actionTable(87,"ValueExpr",SHIFT,31);
          actionTable(87,"CastableExpr",SHIFT,55);
          actionTable(87,"UnionExpr",SHIFT,28);
          actionTable(87,"PrimaryExpr",SHIFT,16);
          actionTable(87,"IntersectExceptExpr",SHIFT,34);
          actionTable(87,"some",SHIFT,40);
          actionTable(87,"IfExpr",SHIFT,53);
          actionTable(87,"digits",SHIFT,9);
          actionTable(87,"RangeExpr",SHIFT,57);
          actionTable(87,"RelativePathExpr",SHIFT,33);
          actionTable(87,"StepExpr",SHIFT,23);
          actionTable(87,"add",SHIFT,25);
          actionTable(87,"NumericLiteral",SHIFT,20);
          actionTable(87,"Expr",SHIFT,88);
          actionTable(87,"QuantifiedExpr",SHIFT,52);
          actionTable(87,"every",SHIFT,36);
          actionTable(87,"dollar",SHIFT,10);
          actionTable(87,"InstanceOfExpr",SHIFT,54);
          actionTable(87,"not",SHIFT,44);
          actionTable(87,"if",SHIFT,2);
          actionTable(87,"AdditiveExpr",SHIFT,60);
          actionTable(87,"ForExpr",SHIFT,49);
          actionTable(87,"ComparisonExpr",SHIFT,56);
          actionTable(87,"FunctionCall",SHIFT,18);
          actionTable(87,"ParenthesizeExpr",SHIFT,75);
          actionTable(87,"PathExpr",SHIFT,32);
          actionTable(87,"subtract",SHIFT,26);
          actionTable(87,"UnaryExpr",SHIFT,64);
          actionTable(87,"backslash",SHIFT,7);
          actionTable(87,"booleanFunc",SHIFT,5);
          actionTable(87,"StringLiteral",SHIFT,21);
          actionTable(87,"name",SHIFT,4);
          actionTable(87,"OrExpr",SHIFT,74);
          actionTable(87,"MultiplicativeExpr",SHIFT,61);
          actionTable(87,"AndExpr",SHIFT,46);

          actionTable(88,"else",SHIFT,89);

          actionTable(89,"StepExpr",SHIFT,23);
          actionTable(89,"UnionExpr",SHIFT,28);
          actionTable(89,"if",SHIFT,2);
          actionTable(89,"FunctionCall",SHIFT,18);
          actionTable(89,"StringLiteral",SHIFT,21);
          actionTable(89,"NumericLiteral",SHIFT,20);
          actionTable(89,"Literal",SHIFT,17);
          actionTable(89,"ValueExpr",SHIFT,31);
          actionTable(89,"PathExpr",SHIFT,32);
          actionTable(89,"digits",SHIFT,9);
          actionTable(89,"PrimaryExpr",SHIFT,16);
          actionTable(89,"UnaryExpr",SHIFT,64);
          actionTable(89,"CastableExpr",SHIFT,55);
          actionTable(89,"add",SHIFT,25);
          actionTable(89,"booleanFunc",SHIFT,5);
          actionTable(89,"RangeExpr",SHIFT,57);
          actionTable(89,"MultiplicativeExpr",SHIFT,61);
          actionTable(89,"IfExpr",SHIFT,90);
          actionTable(89,"name",SHIFT,4);
          actionTable(89,"ComparisonExpr",SHIFT,56);
          actionTable(89,"subtract",SHIFT,26);
          actionTable(89,"RelativePathExpr",SHIFT,33);
          actionTable(89,"AdditiveExpr",SHIFT,60);
          actionTable(89,"IntersectExceptExpr",SHIFT,34);
          actionTable(89,"dollar",SHIFT,10);
          actionTable(89,"backslash",SHIFT,7);
          actionTable(89,"ParenthesizeExpr",SHIFT,19);
          actionTable(89,"InstanceOfExpr",SHIFT,54);
          actionTable(89,"openingParenth",SHIFT,6);

          actionTable(90,"and",REDUCE,15);
          actionTable(90,"or",REDUCE,15);
          actionTable(90,"terminatingCharacter",REDUCE,15);
          actionTable(90,"satisfies",REDUCE,15);
          actionTable(90,"closingParenth",REDUCE,15);
          actionTable(90,"else",REDUCE,15);

          actionTable(91,"#",ACCEPT);

          actionTable(92,"#",REDUCE,1);

          actionTable(93,"terminatingCharacter",SHIFT,94);

          actionTable(94,"#",REDUCE,2);

     }
}